#include "animation.h"
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "ui/ui.h"
#include "lvgl/lvgl.h"
#include <string.h>

// 全局变量定义
bool is_animating = false;         // 速度指针动画状态
bool is_rev_animating = false;      // 转速度指针动画状态
bool is_coolant_animating = false;  // 冷却液温度指针动画状态
bool is_fuel_animating = false;     // 油耗指针动画状态

int current_speed_angle = 0;        // 速度指针当前角度
int current_rev_angle = 0;          // 转速度指针当前角度
int current_coolant_angle = -450;    // 冷却液温度指针当前角度
float current_fuel_angle = FUEL_MIN_ANGLE; // 油耗指针当前角度

int last_revspeed = 0;              // 上次转速度值
int last_coolant_temp = 0;          // 上次冷却液温度值
float last_fuel_consumption = FUEL_CONSUMPTION_MAX; // 上次油耗值

// 油耗指针动画相关变量
static int remaining_steps = 0;     // 剩余动画步数
static float angle_step = 0;        // 单步角度变化量
static float target_consumption = 0; // 目标油耗值

static bool is_speed_animating = false;

/* 动画完成回调函数 */
static void anim_ready_cb(lv_anim_t *a) {
    is_animating = false;
}

/* 油耗单步动画完成回调 */
static void fuel_anim_step_cb(lv_anim_t *a) {
    // 更新当前角度
    current_fuel_angle = lv_img_get_angle(ui_zhizhen4);

    // 更新UI显示
    lv_img_set_angle(ui_zhizhen4, (int16_t)current_fuel_angle);

    // 如果还有剩余步骤，继续动画
    if (--remaining_steps > 0) {
        float next_angle = current_fuel_angle + angle_step;

        // 创建下一步动画
        lv_anim_t next_a;
        lv_anim_init(&next_a);
        lv_anim_set_var(&next_a, ui_zhizhen4);
        lv_anim_set_exec_cb(&next_a, (lv_anim_exec_xcb_t)lv_img_set_angle);
        lv_anim_set_values(&next_a, (int16_t)current_fuel_angle, (int16_t)next_angle);
        lv_anim_set_time(&next_a, STEP_ANIM_TIME);
        lv_anim_set_ready_cb(&next_a, fuel_anim_step_cb);
        lv_anim_start(&next_a);
    }
    else {
        // 所有步骤完成，更新最终状态
        is_fuel_animating = false;
        last_fuel_consumption = target_consumption;
    }
}

// 初始化速度指针
void init_speed_pointer() {
    current_speed_angle = -30;
    lv_img_set_angle(ui_zhizhen1, current_speed_angle);
    lv_img_set_pivot(ui_zhizhen1, 114, 21); // 设置旋转轴
}

// 速度指针动画完成回调
static void speed_anim_ready_cb(lv_anim_t *a) {
    is_speed_animating = false;
}

/* 速度指针动画控制函数 */
void update_speed_pointer(int new_speed) {
    // 计算目标角度(0-2400度对应0-240km/h)
    int target_angle = new_speed * 9.6;

    // 如果正在执行动画，则停止当前动画
    if (is_animating) {
        lv_anim_del(ui_zhizhen1, NULL);
    }

    // 如果角度变化很小，直接设置而不使用动画
    if (abs(target_angle - current_speed_angle) < DIRECT_SET_THRESHOLD) {
        lv_img_set_angle(ui_zhizhen1, target_angle);
        current_speed_angle = target_angle;
        return;
    }

    // 创建动画对象
    lv_anim_t a;
    lv_anim_init(&a);

    // 设置动画参数
    lv_anim_set_var(&a, ui_zhizhen1);
    lv_anim_set_exec_cb(&a, (lv_anim_exec_xcb_t)lv_img_set_angle);
    lv_anim_set_values(&a, current_speed_angle, target_angle);

    // 动态计算动画时间
    int angle_diff = abs(target_angle - current_speed_angle);
    uint16_t anim_time = BASE_ANIM_TIME + angle_diff * ANGLE_TIME_RATIO;
    anim_time = LV_CLAMP(MIN_ANIM_TIME, anim_time, MAX_ANIM_TIME);

    lv_anim_set_time(&a, anim_time);

    // 使用缓出曲线（启动快，结束慢）
    lv_anim_set_path_cb(&a, lv_anim_path_ease_out);

    // 设置动画完成回调
    lv_anim_set_ready_cb(&a, anim_ready_cb);

    // 启动动画
    lv_anim_start(&a);
    is_animating = true;

    // 更新当前角度
    current_speed_angle = target_angle;
}

// 初始化转速度指针
void init_revspeed_pointer() {
    current_rev_angle = -30;
    lv_img_set_angle(ui_zhizhen2, current_rev_angle);
    lv_img_set_pivot(ui_zhizhen2, 114, 21); // 设置旋转轴
}

/* 转速度动画完成回调 */
static void rev_anim_ready_cb(lv_anim_t *a) {
    is_rev_animating = false;
}

/* 转速度指针更新函数 */
void update_revspeed_pointer(int new_revspeed) {
    // 计算目标角度 (每500转=146度)
    int target_angle = (new_revspeed / 500) * REV_BASE_ANGLE;

    // 限制最大角度(假设最大8000转)
    target_angle = LV_CLAMP(0, target_angle, (8000 / 500) * REV_BASE_ANGLE);

    // 如果正在执行动画，则停止当前动画
    if (is_rev_animating) {
        lv_anim_del(ui_zhizhen2, NULL);
    }

    // 小角度变化直接设置
    if (abs(target_angle - current_rev_angle) < REV_MIN_ANGLE_CHANGE) {
        lv_img_set_angle(ui_zhizhen2, target_angle);
        current_rev_angle = target_angle;
        last_revspeed = new_revspeed;
        return;
    }

    // 确定旋转方向
    int direction = (new_revspeed > last_revspeed) ? 1 : -1;

    // 创建动画对象
    lv_anim_t a;
    lv_anim_init(&a);

    // 设置动画参数
    lv_anim_set_var(&a, ui_zhizhen2);
    lv_anim_set_exec_cb(&a, (lv_anim_exec_xcb_t)lv_img_set_angle);

    // 根据方向设置动画值
    if (direction > 0) {
        // 加速 - 顺时针
        lv_anim_set_values(&a, current_rev_angle, target_angle);
    }
    else {
        // 减速 - 逆时针
        lv_anim_set_values(&a, current_rev_angle, target_angle);
    }

    // 动态计算动画时间
    int angle_diff = abs(target_angle - current_rev_angle);
    uint16_t anim_time = REV_BASE_TIME * angle_diff / REV_BASE_ANGLE;
    anim_time = LV_CLAMP(300, anim_time, 1500); // 限制在300-1500ms之间

    lv_anim_set_time(&a, anim_time);

    // 使用缓动曲线
    lv_anim_set_path_cb(&a, direction > 0 ? lv_anim_path_ease_out : lv_anim_path_ease_in);

    // 设置动画完成回调
    lv_anim_set_ready_cb(&a, rev_anim_ready_cb);

    // 启动动画
    lv_anim_start(&a);
    is_rev_animating = true;

    // 更新状态
    current_rev_angle = target_angle;
    last_revspeed = new_revspeed;
}

// 初始化冷却液温度指针
void init_coolant_pointer() {
    current_coolant_angle = FUEL_MIN_ANGLE; // 初始设为最低温度位置
    lv_img_set_angle(ui_zhizhen4, current_coolant_angle);
    lv_img_set_pivot(ui_zhizhen4, 114, 21); // 设置旋转轴
}

/* 冷却液温度动画完成回调 */
static void coolant_anim_ready_cb(lv_anim_t *a) {
    is_coolant_animating = false;
}

/* 冷却液温度指针更新函数 */
void update_coolant_temp(int new_temp) {
    // 确保温度在0-120℃范围内
    new_temp = LV_CLAMP(0, new_temp, COOLANT_TEMP_RANGE);

    // 计算目标角度 (线性映射: 0℃=-450°, 120℃=-570°)
    int target_angle = COOLANT_MAX_ANGLE - (new_temp * COOLANT_ANGLE_RANGE / COOLANT_TEMP_RANGE);

    // 如果正在执行动画，则停止当前动画
    if (is_coolant_animating) {
        lv_anim_del(ui_zhizhen3, NULL);
    }

    // 小角度变化直接设置
    if (abs(target_angle - current_coolant_angle) < COOLANT_MIN_ANGLE_CHANGE) {
        lv_img_set_angle(ui_zhizhen3, target_angle);
        current_coolant_angle = target_angle;
        last_coolant_temp = new_temp;
        return;
    }

    // 确定旋转方向(温度升高时逆时针，降低时顺时针)
    bool is_increasing = (new_temp > last_coolant_temp);

    // 创建动画对象
    lv_anim_t a;
    lv_anim_init(&a);

    // 设置动画参数
    lv_anim_set_var(&a, ui_zhizhen3);
    lv_anim_set_exec_cb(&a, (lv_anim_exec_xcb_t)lv_img_set_angle);
    lv_anim_set_values(&a, current_coolant_angle, target_angle);

    // 动态计算动画时间(基于角度差)
    int angle_diff = abs(target_angle - current_coolant_angle);
    uint16_t anim_time = COOLANT_BASE_TIME * angle_diff / COOLANT_ANGLE_RANGE;
    anim_time = LV_CLAMP(300, anim_time, 1500); // 限制在300-1500ms之间

    lv_anim_set_time(&a, anim_time);

    // 使用不同的缓动曲线增强效果
    lv_anim_set_path_cb(&a, is_increasing ? lv_anim_path_ease_out : lv_anim_path_ease_in);

    // 设置动画完成回调
    lv_anim_set_ready_cb(&a, coolant_anim_ready_cb);

    // 启动动画
    lv_anim_start(&a);
    is_coolant_animating = true;

    // 更新状态
    current_coolant_angle = target_angle;
    last_coolant_temp = new_temp;
}

/* 初始化油耗指针 */
void init_fuel_pointer() {
    // 设置初始角度为最高油耗位置
    current_fuel_angle = FUEL_MIN_ANGLE;
    lv_img_set_angle(ui_zhizhen4, (int16_t)current_fuel_angle);
    lv_img_set_pivot(ui_zhizhen4, 114, 21); // 设置旋转枢轴点

    // 初始化状态
    last_fuel_consumption = FUEL_CONSUMPTION_MAX;
    is_fuel_animating = false;
}

/* 油耗指针异步处理函数 */
void update_fuel_consumption_async(void *param) {
    float *fuel_value = (float *)param;
    if (fuel_value != NULL) {
        update_fuel_consumption(*fuel_value);
        free(fuel_value);
    }
}

/* 油耗指针更新函数 */
void update_fuel_consumption(float new_consumption) {
    // 确保油耗在有效范围内
    new_consumption = LV_CLAMP(FUEL_CONSUMPTION_MIN, new_consumption, FUEL_CONSUMPTION_MAX);

    // 如果正在执行动画，则停止当前动画
    if (is_fuel_animating) {
        lv_anim_del(ui_zhizhen4, NULL);
    }

    // 计算油耗变化量（以0.1为单位）
    float consumption_diff = (new_consumption - last_fuel_consumption) * 10.0f;

    // 确定旋转方向（油耗减少顺时针，增加逆时针）
    float direction = (new_consumption < last_fuel_consumption) ? 1.0f : -1.0f;

    // 计算需要执行的步数（每0.1油耗为一步）
    remaining_steps = (int)fabs(consumption_diff);

    // 计算单步角度变化量（带方向）
    angle_step = ANGLE_PER_STEP * direction;

    // 保存目标值
    target_consumption = new_consumption;

    // 启动第一步动画
    float next_angle = current_fuel_angle + angle_step;

    lv_anim_t a;
    lv_anim_init(&a);
    lv_anim_set_var(&a, ui_zhizhen4);
    lv_anim_set_exec_cb(&a, (lv_anim_exec_xcb_t)lv_img_set_angle);
    lv_anim_set_values(&a, (int16_t)current_fuel_angle, (int16_t)next_angle);
    lv_anim_set_time(&a, STEP_ANIM_TIME);
    lv_anim_set_ready_cb(&a, fuel_anim_step_cb);
    lv_anim_start(&a);

    // 更新动画状态
    is_fuel_animating = true;
}
